// Generated from src/antlr/ArkcubeScript.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { ArkcubeScriptListener } from "./ArkcubeScriptListener";
import { ArkcubeScriptVisitor } from "./ArkcubeScriptVisitor";


export class ArkcubeScriptParser extends Parser {
	public static readonly Number = 1;
	public static readonly StringLiteral = 2;
	public static readonly BooleanLiteral = 3;
	public static readonly CellDBView = 4;
	public static readonly CellEXView = 5;
	public static readonly CellView = 6;
	public static readonly Function = 7;
	public static readonly Import = 8;
	public static readonly As = 9;
	public static readonly From = 10;
	public static readonly End = 11;
	public static readonly If = 12;
	public static readonly Elseif = 13;
	public static readonly Else = 14;
	public static readonly While = 15;
	public static readonly Return = 16;
	public static readonly Plus = 17;
	public static readonly Minus = 18;
	public static readonly Star = 19;
	public static readonly Div = 20;
	public static readonly Div2 = 21;
	public static readonly Caret = 22;
	public static readonly Or = 23;
	public static readonly Comma = 24;
	public static readonly Dot = 25;
	public static readonly Colon = 26;
	public static readonly Sharp = 27;
	public static readonly Not = 28;
	public static readonly And = 29;
	public static readonly Percent = 30;
	public static readonly Tilde = 31;
	public static readonly Equal = 32;
	public static readonly NotEqual = 33;
	public static readonly Greater = 34;
	public static readonly GreaterEqual = 35;
	public static readonly Less = 36;
	public static readonly LessEqual = 37;
	public static readonly StrEqual = 38;
	public static readonly StrNotEqual = 39;
	public static readonly StrGreater = 40;
	public static readonly StrGreaterEqual = 41;
	public static readonly StrLess = 42;
	public static readonly StrLessEqual = 43;
	public static readonly Feed = 44;
	public static readonly SingleQuote = 45;
	public static readonly Semi = 46;
	public static readonly LeftParen = 47;
	public static readonly RightParen = 48;
	public static readonly LeftBracket = 49;
	public static readonly RightBracket = 50;
	public static readonly LeftBrace = 51;
	public static readonly RightBrace = 52;
	public static readonly Identifier = 53;
	public static readonly NewLine = 54;
	public static readonly WhiteSpace = 55;
	public static readonly LineComment = 56;
	public static readonly RULE_program = 0;
	public static readonly RULE_stat = 1;
	public static readonly RULE_importStat = 2;
	public static readonly RULE_viewStat = 3;
	public static readonly RULE_cellViewStat = 4;
	public static readonly RULE_cellEXViewStat = 5;
	public static readonly RULE_cellDBViewStat = 6;
	public static readonly RULE_variableDecl = 7;
	public static readonly RULE_type = 8;
	public static readonly RULE_functionDecl = 9;
	public static readonly RULE_parameterList = 10;
	public static readonly RULE_parameter = 11;
	public static readonly RULE_block = 12;
	public static readonly RULE_ifStat = 13;
	public static readonly RULE_whileStat = 14;
	public static readonly RULE_returnStat = 15;
	public static readonly RULE_expr = 16;
	public static readonly RULE_functionCall = 17;
	public static readonly RULE_arguments = 18;
	public static readonly RULE_dim = 19;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"program", "stat", "importStat", "viewStat", "cellViewStat", "cellEXViewStat", 
		"cellDBViewStat", "variableDecl", "type", "functionDecl", "parameterList", 
		"parameter", "block", "ifStat", "whileStat", "returnStat", "expr", "functionCall", 
		"arguments", "dim",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, "'+'", "'-'", "'*'", "'/'", "'\\'", "'^'", 
		"'|'", "','", "'.'", "':'", "'#'", "'!'", "'&'", "'%'", "'~'", "'='", 
		"'<>'", "'>'", "'>='", "'<'", "'<='", "'@='", "'@<>'", "'@>'", "'@>='", 
		"'@<'", "'@<='", "'=>'", "'''", "';'", "'('", "')'", "'['", "']'", "'{'", 
		"'}'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, "Number", "StringLiteral", "BooleanLiteral", "CellDBView", 
		"CellEXView", "CellView", "Function", "Import", "As", "From", "End", "If", 
		"Elseif", "Else", "While", "Return", "Plus", "Minus", "Star", "Div", "Div2", 
		"Caret", "Or", "Comma", "Dot", "Colon", "Sharp", "Not", "And", "Percent", 
		"Tilde", "Equal", "NotEqual", "Greater", "GreaterEqual", "Less", "LessEqual", 
		"StrEqual", "StrNotEqual", "StrGreater", "StrGreaterEqual", "StrLess", 
		"StrLessEqual", "Feed", "SingleQuote", "Semi", "LeftParen", "RightParen", 
		"LeftBracket", "RightBracket", "LeftBrace", "RightBrace", "Identifier", 
		"NewLine", "WhiteSpace", "LineComment",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(ArkcubeScriptParser._LITERAL_NAMES, ArkcubeScriptParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return ArkcubeScriptParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "ArkcubeScript.g4"; }

	// @Override
	public get ruleNames(): string[] { return ArkcubeScriptParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return ArkcubeScriptParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(ArkcubeScriptParser._ATN, this);
	}
	// @RuleVersion(0)
	public program(): ProgramContext {
		let _localctx: ProgramContext = new ProgramContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, ArkcubeScriptParser.RULE_program);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 43;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
				{
				{
				this.state = 40;
				this.stat();
				}
				}
				this.state = 45;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 46;
			this.match(ArkcubeScriptParser.EOF);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public stat(): StatContext {
		let _localctx: StatContext = new StatContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, ArkcubeScriptParser.RULE_stat);
		try {
			this.state = 72;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 2, this._ctx) ) {
			case 1:
				_localctx = new ImportStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 48;
				this.importStat();
				this.state = 49;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 2:
				_localctx = new ViewStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 51;
				this.viewStat();
				this.state = 52;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 3:
				_localctx = new VariableDeclStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 54;
				this.variableDecl();
				this.state = 55;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 4:
				_localctx = new FunctionDeclStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 57;
				this.functionDecl();
				this.state = 58;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 5:
				_localctx = new ControlStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 62;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case ArkcubeScriptParser.If:
					{
					this.state = 60;
					this.ifStat();
					}
					break;
				case ArkcubeScriptParser.While:
					{
					this.state = 61;
					this.whileStat();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 64;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 6:
				_localctx = new ReturnStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 66;
				this.returnStat();
				this.state = 67;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;

			case 7:
				_localctx = new ExprStatementContext(_localctx);
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 69;
				this.expr(0);
				this.state = 70;
				this.match(ArkcubeScriptParser.Semi);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public importStat(): ImportStatContext {
		let _localctx: ImportStatContext = new ImportStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, ArkcubeScriptParser.RULE_importStat);
		try {
			this.state = 92;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 3, this._ctx) ) {
			case 1:
				_localctx = new ModuleAliasContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 74;
				this.match(ArkcubeScriptParser.Import);
				this.state = 75;
				(_localctx as ModuleAliasContext)._name = this.match(ArkcubeScriptParser.StringLiteral);
				this.state = 76;
				this.match(ArkcubeScriptParser.As);
				this.state = 77;
				(_localctx as ModuleAliasContext)._alias = this.match(ArkcubeScriptParser.Identifier);
				}
				break;

			case 2:
				_localctx = new ModuleSymbolContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 78;
				this.match(ArkcubeScriptParser.From);
				this.state = 79;
				(_localctx as ModuleSymbolContext)._name = this.match(ArkcubeScriptParser.StringLiteral);
				this.state = 80;
				this.match(ArkcubeScriptParser.Import);
				this.state = 81;
				(_localctx as ModuleSymbolContext)._mod = this.match(ArkcubeScriptParser.Identifier);
				}
				break;

			case 3:
				_localctx = new ModuleSymbolAliasContext(_localctx);
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 82;
				this.match(ArkcubeScriptParser.From);
				this.state = 83;
				(_localctx as ModuleSymbolAliasContext)._name = this.match(ArkcubeScriptParser.StringLiteral);
				this.state = 84;
				this.match(ArkcubeScriptParser.Import);
				this.state = 85;
				(_localctx as ModuleSymbolAliasContext)._mod = this.match(ArkcubeScriptParser.Identifier);
				this.state = 86;
				this.match(ArkcubeScriptParser.As);
				this.state = 87;
				(_localctx as ModuleSymbolAliasContext)._alias = this.match(ArkcubeScriptParser.Identifier);
				}
				break;

			case 4:
				_localctx = new ModuleAllSymbolContext(_localctx);
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 88;
				this.match(ArkcubeScriptParser.From);
				this.state = 89;
				(_localctx as ModuleAllSymbolContext)._name = this.match(ArkcubeScriptParser.StringLiteral);
				this.state = 90;
				this.match(ArkcubeScriptParser.Import);
				this.state = 91;
				this.match(ArkcubeScriptParser.Star);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public viewStat(): ViewStatContext {
		let _localctx: ViewStatContext = new ViewStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, ArkcubeScriptParser.RULE_viewStat);
		try {
			this.state = 97;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case ArkcubeScriptParser.CellView:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 94;
				this.cellViewStat();
				}
				break;
			case ArkcubeScriptParser.CellEXView:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 95;
				this.cellEXViewStat();
				}
				break;
			case ArkcubeScriptParser.CellDBView:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 96;
				this.cellDBViewStat();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellViewStat(): CellViewStatContext {
		let _localctx: CellViewStatContext = new CellViewStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, ArkcubeScriptParser.RULE_cellViewStat);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 99;
			this.match(ArkcubeScriptParser.CellView);
			this.state = 100;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 101;
			this.arguments();
			this.state = 102;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 103;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 104;
			this.block();
			this.state = 105;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellEXViewStat(): CellEXViewStatContext {
		let _localctx: CellEXViewStatContext = new CellEXViewStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, ArkcubeScriptParser.RULE_cellEXViewStat);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 107;
			this.match(ArkcubeScriptParser.CellEXView);
			this.state = 108;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 109;
			this.arguments();
			this.state = 110;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 111;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 112;
			this.block();
			this.state = 113;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public cellDBViewStat(): CellDBViewStatContext {
		let _localctx: CellDBViewStatContext = new CellDBViewStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, ArkcubeScriptParser.RULE_cellDBViewStat);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 115;
			this.match(ArkcubeScriptParser.CellDBView);
			this.state = 116;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 117;
			this.arguments();
			this.state = 118;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 119;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 120;
			this.block();
			this.state = 121;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public variableDecl(): VariableDeclContext {
		let _localctx: VariableDeclContext = new VariableDeclContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, ArkcubeScriptParser.RULE_variableDecl);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 123;
			this.type();
			this.state = 124;
			this.match(ArkcubeScriptParser.Identifier);
			this.state = 127;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === ArkcubeScriptParser.Equal) {
				{
				this.state = 125;
				this.match(ArkcubeScriptParser.Equal);
				this.state = 126;
				this.expr(0);
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public type(): TypeContext {
		let _localctx: TypeContext = new TypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, ArkcubeScriptParser.RULE_type);
		try {
			this.state = 133;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 6, this._ctx) ) {
			case 1:
				_localctx = new ArrayTypeContext(_localctx);
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 129;
				this.match(ArkcubeScriptParser.Identifier);
				this.state = 130;
				this.match(ArkcubeScriptParser.LeftBracket);
				this.state = 131;
				this.match(ArkcubeScriptParser.RightBracket);
				}
				break;

			case 2:
				_localctx = new SimpleTypeContext(_localctx);
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 132;
				this.match(ArkcubeScriptParser.Identifier);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionDecl(): FunctionDeclContext {
		let _localctx: FunctionDeclContext = new FunctionDeclContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, ArkcubeScriptParser.RULE_functionDecl);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 135;
			this.type();
			this.state = 136;
			this.match(ArkcubeScriptParser.Function);
			this.state = 137;
			this.match(ArkcubeScriptParser.Identifier);
			this.state = 138;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 140;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === ArkcubeScriptParser.Identifier) {
				{
				this.state = 139;
				this.parameterList();
				}
			}

			this.state = 142;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 143;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 144;
			this.block();
			this.state = 145;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public parameterList(): ParameterListContext {
		let _localctx: ParameterListContext = new ParameterListContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, ArkcubeScriptParser.RULE_parameterList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 147;
			this.parameter();
			this.state = 152;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === ArkcubeScriptParser.Comma) {
				{
				{
				this.state = 148;
				this.match(ArkcubeScriptParser.Comma);
				this.state = 149;
				this.parameter();
				}
				}
				this.state = 154;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public parameter(): ParameterContext {
		let _localctx: ParameterContext = new ParameterContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, ArkcubeScriptParser.RULE_parameter);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 155;
			this.type();
			this.state = 156;
			this.match(ArkcubeScriptParser.Identifier);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public block(): BlockContext {
		let _localctx: BlockContext = new BlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, ArkcubeScriptParser.RULE_block);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 161;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
				{
				{
				this.state = 158;
				this.stat();
				}
				}
				this.state = 163;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifStat(): IfStatContext {
		let _localctx: IfStatContext = new IfStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, ArkcubeScriptParser.RULE_ifStat);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 164;
			this.match(ArkcubeScriptParser.If);
			this.state = 165;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 166;
			this.expr(0);
			this.state = 167;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 168;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 172;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
				{
				{
				this.state = 169;
				this.stat();
				}
				}
				this.state = 174;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 188;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === ArkcubeScriptParser.Elseif) {
				{
				{
				this.state = 175;
				this.match(ArkcubeScriptParser.Elseif);
				this.state = 176;
				this.match(ArkcubeScriptParser.LeftParen);
				this.state = 177;
				this.expr(0);
				this.state = 178;
				this.match(ArkcubeScriptParser.RightParen);
				this.state = 179;
				this.match(ArkcubeScriptParser.Semi);
				this.state = 183;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
					{
					{
					this.state = 180;
					this.stat();
					}
					}
					this.state = 185;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				}
				this.state = 190;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 199;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === ArkcubeScriptParser.Else) {
				{
				this.state = 191;
				this.match(ArkcubeScriptParser.Else);
				this.state = 192;
				this.match(ArkcubeScriptParser.Semi);
				this.state = 196;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
					{
					{
					this.state = 193;
					this.stat();
					}
					}
					this.state = 198;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
			}

			this.state = 201;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public whileStat(): WhileStatContext {
		let _localctx: WhileStatContext = new WhileStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 28, ArkcubeScriptParser.RULE_whileStat);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 203;
			this.match(ArkcubeScriptParser.While);
			this.state = 204;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 205;
			this.expr(0);
			this.state = 206;
			this.match(ArkcubeScriptParser.RightParen);
			this.state = 207;
			this.match(ArkcubeScriptParser.Semi);
			this.state = 211;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.CellDBView) | (1 << ArkcubeScriptParser.CellEXView) | (1 << ArkcubeScriptParser.CellView) | (1 << ArkcubeScriptParser.Import) | (1 << ArkcubeScriptParser.From) | (1 << ArkcubeScriptParser.If) | (1 << ArkcubeScriptParser.While) | (1 << ArkcubeScriptParser.Return) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
				{
				{
				this.state = 208;
				this.stat();
				}
				}
				this.state = 213;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 214;
			this.match(ArkcubeScriptParser.End);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public returnStat(): ReturnStatContext {
		let _localctx: ReturnStatContext = new ReturnStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 30, ArkcubeScriptParser.RULE_returnStat);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 216;
			this.match(ArkcubeScriptParser.Return);
			this.state = 217;
			this.expr(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public expr(): ExprContext;
	public expr(_p: number): ExprContext;
	// @RuleVersion(0)
	public expr(_p?: number): ExprContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: ExprContext = new ExprContext(this._ctx, _parentState);
		let _prevctx: ExprContext = _localctx;
		let _startState: number = 32;
		this.enterRecursionRule(_localctx, 32, ArkcubeScriptParser.RULE_expr, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 242;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
			case 1:
				{
				_localctx = new NumberContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;

				this.state = 220;
				this.match(ArkcubeScriptParser.Number);
				}
				break;

			case 2:
				{
				_localctx = new StringLiteralContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 221;
				this.match(ArkcubeScriptParser.StringLiteral);
				}
				break;

			case 3:
				{
				_localctx = new BooleanLiteralContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 222;
				this.match(ArkcubeScriptParser.BooleanLiteral);
				}
				break;

			case 4:
				{
				_localctx = new NameContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 223;
				this.match(ArkcubeScriptParser.Identifier);
				}
				break;

			case 5:
				{
				_localctx = new DimColonContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 224;
				this.dim();
				this.state = 225;
				this.match(ArkcubeScriptParser.Colon);
				this.state = 226;
				this.expr(12);
				}
				break;

			case 6:
				{
				_localctx = new MemberSetContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 228;
				this.match(ArkcubeScriptParser.LeftBrace);
				this.state = 229;
				this.arguments();
				this.state = 230;
				this.match(ArkcubeScriptParser.RightBrace);
				}
				break;

			case 7:
				{
				_localctx = new PrefixExpressionContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 232;
				(_localctx as PrefixExpressionContext)._op = this._input.LT(1);
				_la = this._input.LA(1);
				if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0))) {
					(_localctx as PrefixExpressionContext)._op = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 233;
				(_localctx as PrefixExpressionContext)._right = this.expr(9);
				}
				break;

			case 8:
				{
				_localctx = new PriorityExpressionContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 234;
				this.match(ArkcubeScriptParser.LeftParen);
				this.state = 235;
				this.expr(0);
				this.state = 236;
				this.match(ArkcubeScriptParser.RightParen);
				}
				break;

			case 9:
				{
				_localctx = new FunctionApplyContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 238;
				this.functionCall();
				}
				break;

			case 10:
				{
				_localctx = new DotFunctionApplyContext(_localctx);
				this._ctx = _localctx;
				_prevctx = _localctx;
				this.state = 239;
				this.match(ArkcubeScriptParser.Identifier);
				this.state = 240;
				this.match(ArkcubeScriptParser.Dot);
				this.state = 241;
				this.functionCall();
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 272;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 270;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 17, this._ctx) ) {
					case 1:
						{
						_localctx = new PowerLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as PowerLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 244;
						if (!(this.precpred(this._ctx, 10))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 10)");
						}
						this.state = 245;
						(_localctx as PowerLikeContext)._op = this.match(ArkcubeScriptParser.Caret);
						this.state = 246;
						(_localctx as PowerLikeContext)._right = this.expr(11);
						}
						break;

					case 2:
						{
						_localctx = new MultiplyLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as MultiplyLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 247;
						if (!(this.precpred(this._ctx, 8))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 8)");
						}
						this.state = 248;
						(_localctx as MultiplyLikeContext)._op = this._input.LT(1);
						_la = this._input.LA(1);
						if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Star) | (1 << ArkcubeScriptParser.Div) | (1 << ArkcubeScriptParser.Div2))) !== 0))) {
							(_localctx as MultiplyLikeContext)._op = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 249;
						(_localctx as MultiplyLikeContext)._right = this.expr(9);
						}
						break;

					case 3:
						{
						_localctx = new PlusLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as PlusLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 250;
						if (!(this.precpred(this._ctx, 7))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
						}
						this.state = 251;
						(_localctx as PlusLikeContext)._op = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === ArkcubeScriptParser.Plus || _la === ArkcubeScriptParser.Minus)) {
							(_localctx as PlusLikeContext)._op = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 252;
						(_localctx as PlusLikeContext)._right = this.expr(8);
						}
						break;

					case 4:
						{
						_localctx = new ListLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as ListLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 253;
						if (!(this.precpred(this._ctx, 6))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
						}
						this.state = 254;
						(_localctx as ListLikeContext)._op = this.match(ArkcubeScriptParser.Or);
						this.state = 255;
						(_localctx as ListLikeContext)._right = this.expr(7);
						}
						break;

					case 5:
						{
						_localctx = new CompareLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as CompareLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 256;
						if (!(this.precpred(this._ctx, 5))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
						}
						this.state = 257;
						(_localctx as CompareLikeContext)._op = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ArkcubeScriptParser.Equal - 32)) | (1 << (ArkcubeScriptParser.NotEqual - 32)) | (1 << (ArkcubeScriptParser.Greater - 32)) | (1 << (ArkcubeScriptParser.GreaterEqual - 32)) | (1 << (ArkcubeScriptParser.Less - 32)) | (1 << (ArkcubeScriptParser.LessEqual - 32)) | (1 << (ArkcubeScriptParser.StrEqual - 32)) | (1 << (ArkcubeScriptParser.StrNotEqual - 32)) | (1 << (ArkcubeScriptParser.StrGreater - 32)) | (1 << (ArkcubeScriptParser.StrGreaterEqual - 32)) | (1 << (ArkcubeScriptParser.StrLess - 32)) | (1 << (ArkcubeScriptParser.StrLessEqual - 32)))) !== 0))) {
							(_localctx as CompareLikeContext)._op = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 258;
						(_localctx as CompareLikeContext)._right = this.expr(6);
						}
						break;

					case 6:
						{
						_localctx = new LogicLikeContext(new ExprContext(_parentctx, _parentState));
						(_localctx as LogicLikeContext)._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 259;
						if (!(this.precpred(this._ctx, 4))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
						}
						this.state = 260;
						(_localctx as LogicLikeContext)._op = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === ArkcubeScriptParser.And || _la === ArkcubeScriptParser.Percent)) {
							(_localctx as LogicLikeContext)._op = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 261;
						(_localctx as LogicLikeContext)._right = this.expr(5);
						}
						break;

					case 7:
						{
						_localctx = new ArrayIndexContext(new ExprContext(_parentctx, _parentState));
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 262;
						if (!(this.precpred(this._ctx, 14))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 14)");
						}
						this.state = 263;
						this.match(ArkcubeScriptParser.LeftBracket);
						this.state = 264;
						this.expr(0);
						this.state = 265;
						this.match(ArkcubeScriptParser.RightBracket);
						}
						break;

					case 8:
						{
						_localctx = new MemberRangeContext(new ExprContext(_parentctx, _parentState));
						this.pushNewRecursionContext(_localctx, _startState, ArkcubeScriptParser.RULE_expr);
						this.state = 267;
						if (!(this.precpred(this._ctx, 13))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 13)");
						}
						this.state = 268;
						this.match(ArkcubeScriptParser.Dot);
						this.state = 269;
						this.match(ArkcubeScriptParser.Identifier);
						}
						break;
					}
					}
				}
				this.state = 274;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionCall(): FunctionCallContext {
		let _localctx: FunctionCallContext = new FunctionCallContext(this._ctx, this.state);
		this.enterRule(_localctx, 34, ArkcubeScriptParser.RULE_functionCall);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 275;
			this.match(ArkcubeScriptParser.Identifier);
			this.state = 276;
			this.match(ArkcubeScriptParser.LeftParen);
			this.state = 278;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ArkcubeScriptParser.Number) | (1 << ArkcubeScriptParser.StringLiteral) | (1 << ArkcubeScriptParser.BooleanLiteral) | (1 << ArkcubeScriptParser.Plus) | (1 << ArkcubeScriptParser.Minus) | (1 << ArkcubeScriptParser.Tilde))) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & ((1 << (ArkcubeScriptParser.LeftParen - 47)) | (1 << (ArkcubeScriptParser.LeftBrace - 47)) | (1 << (ArkcubeScriptParser.Identifier - 47)))) !== 0)) {
				{
				this.state = 277;
				this.arguments();
				}
			}

			this.state = 280;
			this.match(ArkcubeScriptParser.RightParen);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public arguments(): ArgumentsContext {
		let _localctx: ArgumentsContext = new ArgumentsContext(this._ctx, this.state);
		this.enterRule(_localctx, 36, ArkcubeScriptParser.RULE_arguments);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 282;
			this.expr(0);
			this.state = 287;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === ArkcubeScriptParser.Comma) {
				{
				{
				this.state = 283;
				this.match(ArkcubeScriptParser.Comma);
				this.state = 284;
				this.expr(0);
				}
				}
				this.state = 289;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dim(): DimContext {
		let _localctx: DimContext = new DimContext(this._ctx, this.state);
		this.enterRule(_localctx, 38, ArkcubeScriptParser.RULE_dim);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 290;
			_la = this._input.LA(1);
			if (!(_la === ArkcubeScriptParser.StringLiteral || _la === ArkcubeScriptParser.Identifier)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
		switch (ruleIndex) {
		case 16:
			return this.expr_sempred(_localctx as ExprContext, predIndex);
		}
		return true;
	}
	private expr_sempred(_localctx: ExprContext, predIndex: number): boolean {
		switch (predIndex) {
		case 0:
			return this.precpred(this._ctx, 10);

		case 1:
			return this.precpred(this._ctx, 8);

		case 2:
			return this.precpred(this._ctx, 7);

		case 3:
			return this.precpred(this._ctx, 6);

		case 4:
			return this.precpred(this._ctx, 5);

		case 5:
			return this.precpred(this._ctx, 4);

		case 6:
			return this.precpred(this._ctx, 14);

		case 7:
			return this.precpred(this._ctx, 13);
		}
		return true;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03:\u0127\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
		"\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
		"\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x03\x02\x07\x02,\n\x02\f\x02\x0E" +
		"\x02/\v\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
		"\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x05" +
		"\x03A\n\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
		"\x03\x05\x03K\n\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x05\x04_\n\x04\x03\x05\x03\x05\x03\x05\x05\x05d\n" +
		"\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03" +
		"\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\t\x03\t\x03\t\x03\t\x05\t\x82" +
		"\n\t\x03\n\x03\n\x03\n\x03\n\x05\n\x88\n\n\x03\v\x03\v\x03\v\x03\v\x03" +
		"\v\x05\v\x8F\n\v\x03\v\x03\v\x03\v\x03\v\x03\v\x03\f\x03\f\x03\f\x07\f" +
		"\x99\n\f\f\f\x0E\f\x9C\v\f\x03\r\x03\r\x03\r\x03\x0E\x07\x0E\xA2\n\x0E" +
		"\f\x0E\x0E\x0E\xA5\v\x0E\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F" +
		"\x07\x0F\xAD\n\x0F\f\x0F\x0E\x0F\xB0\v\x0F\x03\x0F\x03\x0F\x03\x0F\x03" +
		"\x0F\x03\x0F\x03\x0F\x07\x0F\xB8\n\x0F\f\x0F\x0E\x0F\xBB\v\x0F\x07\x0F" +
		"\xBD\n\x0F\f\x0F\x0E\x0F\xC0\v\x0F\x03\x0F\x03\x0F\x03\x0F\x07\x0F\xC5" +
		"\n\x0F\f\x0F\x0E\x0F\xC8\v\x0F\x05\x0F\xCA\n\x0F\x03\x0F\x03\x0F\x03\x10" +
		"\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x07\x10\xD4\n\x10\f\x10\x0E\x10" +
		"\xD7\v\x10\x03\x10\x03\x10\x03\x11\x03\x11\x03\x11\x03\x12\x03\x12\x03" +
		"\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03" +
		"\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03" +
		"\x12\x03\x12\x03\x12\x05\x12\xF5\n\x12\x03\x12\x03\x12\x03\x12\x03\x12" +
		"\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12" +
		"\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12" +
		"\x03\x12\x03\x12\x03\x12\x03\x12\x07\x12\u0111\n\x12\f\x12\x0E\x12\u0114" +
		"\v\x12\x03\x13\x03\x13\x03\x13\x05\x13\u0119\n\x13\x03\x13\x03\x13\x03" +
		"\x14\x03\x14\x03\x14\x07\x14\u0120\n\x14\f\x14\x0E\x14\u0123\v\x14\x03" +
		"\x15\x03\x15\x03\x15\x02\x02\x03\"\x16\x02\x02\x04\x02\x06\x02\b\x02\n" +
		"\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C" +
		"\x02\x1E\x02 \x02\"\x02$\x02&\x02(\x02\x02\b\x04\x02\x13\x14!!\x03\x02" +
		"\x15\x17\x03\x02\x13\x14\x03\x02\"-\x03\x02\x1F \x04\x02\x04\x0477\x02" +
		"\u013D\x02-\x03\x02\x02\x02\x04J\x03\x02\x02\x02\x06^\x03\x02\x02\x02" +
		"\bc\x03\x02\x02\x02\ne\x03\x02\x02\x02\fm\x03\x02\x02\x02\x0Eu\x03\x02" +
		"\x02\x02\x10}\x03\x02\x02\x02\x12\x87\x03\x02\x02\x02\x14\x89\x03\x02" +
		"\x02\x02\x16\x95\x03\x02\x02\x02\x18\x9D\x03\x02\x02\x02\x1A\xA3\x03\x02" +
		"\x02\x02\x1C\xA6\x03\x02\x02\x02\x1E\xCD\x03\x02\x02\x02 \xDA\x03\x02" +
		"\x02\x02\"\xF4\x03\x02\x02\x02$\u0115\x03\x02\x02\x02&\u011C\x03\x02\x02" +
		"\x02(\u0124\x03\x02\x02\x02*,\x05\x04\x03\x02+*\x03\x02\x02\x02,/\x03" +
		"\x02\x02\x02-+\x03\x02\x02\x02-.\x03\x02\x02\x02.0\x03\x02\x02\x02/-\x03" +
		"\x02\x02\x0201\x07\x02\x02\x031\x03\x03\x02\x02\x0223\x05\x06\x04\x02" +
		"34\x070\x02\x024K\x03\x02\x02\x0256\x05\b\x05\x0267\x070\x02\x027K\x03" +
		"\x02\x02\x0289\x05\x10\t\x029:\x070\x02\x02:K\x03\x02\x02\x02;<\x05\x14" +
		"\v\x02<=\x070\x02\x02=K\x03\x02\x02\x02>A\x05\x1C\x0F\x02?A\x05\x1E\x10" +
		"\x02@>\x03\x02\x02\x02@?\x03\x02\x02\x02AB\x03\x02\x02\x02BC\x070\x02" +
		"\x02CK\x03\x02\x02\x02DE\x05 \x11\x02EF\x070\x02\x02FK\x03\x02\x02\x02" +
		"GH\x05\"\x12\x02HI\x070\x02\x02IK\x03\x02\x02\x02J2\x03\x02\x02\x02J5" +
		"\x03\x02\x02\x02J8\x03\x02\x02\x02J;\x03\x02\x02\x02J@\x03\x02\x02\x02" +
		"JD\x03\x02\x02\x02JG\x03\x02\x02\x02K\x05\x03\x02\x02\x02LM\x07\n\x02" +
		"\x02MN\x07\x04\x02\x02NO\x07\v\x02\x02O_\x077\x02\x02PQ\x07\f\x02\x02" +
		"QR\x07\x04\x02\x02RS\x07\n\x02\x02S_\x077\x02\x02TU\x07\f\x02\x02UV\x07" +
		"\x04\x02\x02VW\x07\n\x02\x02WX\x077\x02\x02XY\x07\v\x02\x02Y_\x077\x02" +
		"\x02Z[\x07\f\x02\x02[\\\x07\x04\x02\x02\\]\x07\n\x02\x02]_\x07\x15\x02" +
		"\x02^L\x03\x02\x02\x02^P\x03\x02\x02\x02^T\x03\x02\x02\x02^Z\x03\x02\x02" +
		"\x02_\x07\x03\x02\x02\x02`d\x05\n\x06\x02ad\x05\f\x07\x02bd\x05\x0E\b" +
		"\x02c`\x03\x02\x02\x02ca\x03\x02\x02\x02cb\x03\x02\x02\x02d\t\x03\x02" +
		"\x02\x02ef\x07\b\x02\x02fg\x071\x02\x02gh\x05&\x14\x02hi\x072\x02\x02" +
		"ij\x070\x02\x02jk\x05\x1A\x0E\x02kl\x07\r\x02\x02l\v\x03\x02\x02\x02m" +
		"n\x07\x07\x02\x02no\x071\x02\x02op\x05&\x14\x02pq\x072\x02\x02qr\x070" +
		"\x02\x02rs\x05\x1A\x0E\x02st\x07\r\x02\x02t\r\x03\x02\x02\x02uv\x07\x06" +
		"\x02\x02vw\x071\x02\x02wx\x05&\x14\x02xy\x072\x02\x02yz\x070\x02\x02z" +
		"{\x05\x1A\x0E\x02{|\x07\r\x02\x02|\x0F\x03\x02\x02\x02}~\x05\x12\n\x02" +
		"~\x81\x077\x02\x02\x7F\x80\x07\"\x02\x02\x80\x82\x05\"\x12\x02\x81\x7F" +
		"\x03\x02\x02\x02\x81\x82\x03\x02\x02\x02\x82\x11\x03\x02\x02\x02\x83\x84" +
		"\x077\x02\x02\x84\x85\x073\x02\x02\x85\x88\x074\x02\x02\x86\x88\x077\x02" +
		"\x02\x87\x83\x03\x02\x02\x02\x87\x86\x03\x02\x02\x02\x88\x13\x03\x02\x02" +
		"\x02\x89\x8A\x05\x12\n\x02\x8A\x8B\x07\t\x02\x02\x8B\x8C\x077\x02\x02" +
		"\x8C\x8E\x071\x02\x02\x8D\x8F\x05\x16\f\x02\x8E\x8D\x03\x02\x02\x02\x8E" +
		"\x8F\x03\x02\x02\x02\x8F\x90\x03\x02\x02\x02\x90\x91\x072\x02\x02\x91" +
		"\x92\x070\x02\x02\x92\x93\x05\x1A\x0E\x02\x93\x94\x07\r\x02\x02\x94\x15" +
		"\x03\x02\x02\x02\x95\x9A\x05\x18\r\x02\x96\x97\x07\x1A\x02\x02\x97\x99" +
		"\x05\x18\r\x02\x98\x96\x03\x02\x02\x02\x99\x9C\x03\x02\x02\x02\x9A\x98" +
		"\x03\x02\x02\x02\x9A\x9B\x03\x02\x02\x02\x9B\x17\x03\x02\x02\x02\x9C\x9A" +
		"\x03\x02\x02\x02\x9D\x9E\x05\x12\n\x02\x9E\x9F\x077\x02\x02\x9F\x19\x03" +
		"\x02\x02\x02\xA0\xA2\x05\x04\x03\x02\xA1\xA0\x03\x02\x02\x02\xA2\xA5\x03" +
		"\x02\x02\x02\xA3\xA1\x03\x02\x02\x02\xA3\xA4\x03\x02\x02\x02\xA4\x1B\x03" +
		"\x02\x02\x02\xA5\xA3\x03\x02\x02\x02\xA6\xA7\x07\x0E\x02\x02\xA7\xA8\x07" +
		"1\x02\x02\xA8\xA9\x05\"\x12\x02\xA9\xAA\x072\x02\x02\xAA\xAE\x070\x02" +
		"\x02\xAB\xAD\x05\x04\x03\x02\xAC\xAB\x03\x02\x02\x02\xAD\xB0\x03\x02\x02" +
		"\x02\xAE\xAC\x03\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF\xBE\x03\x02\x02" +
		"\x02\xB0\xAE\x03\x02\x02\x02\xB1\xB2\x07\x0F\x02\x02\xB2\xB3\x071\x02" +
		"\x02\xB3\xB4\x05\"\x12\x02\xB4\xB5\x072\x02\x02\xB5\xB9\x070\x02\x02\xB6" +
		"\xB8\x05\x04\x03\x02\xB7\xB6\x03\x02\x02\x02\xB8\xBB\x03\x02\x02\x02\xB9" +
		"\xB7\x03\x02\x02\x02\xB9\xBA\x03\x02\x02\x02\xBA\xBD\x03\x02\x02\x02\xBB" +
		"\xB9\x03\x02\x02\x02\xBC\xB1\x03\x02\x02\x02\xBD\xC0\x03\x02\x02\x02\xBE" +
		"\xBC\x03\x02\x02\x02\xBE\xBF\x03\x02\x02\x02\xBF\xC9\x03\x02\x02\x02\xC0" +
		"\xBE\x03\x02\x02\x02\xC1\xC2\x07\x10\x02\x02\xC2\xC6\x070\x02\x02\xC3" +
		"\xC5\x05\x04\x03\x02\xC4\xC3\x03\x02\x02\x02\xC5\xC8\x03\x02\x02\x02\xC6" +
		"\xC4\x03\x02\x02\x02\xC6\xC7\x03\x02\x02\x02\xC7\xCA\x03\x02\x02\x02\xC8" +
		"\xC6\x03\x02\x02\x02\xC9\xC1\x03\x02\x02\x02\xC9\xCA\x03\x02\x02\x02\xCA" +
		"\xCB\x03\x02\x02\x02\xCB\xCC\x07\r\x02\x02\xCC\x1D\x03\x02\x02\x02\xCD" +
		"\xCE\x07\x11\x02\x02\xCE\xCF\x071\x02\x02\xCF\xD0\x05\"\x12\x02\xD0\xD1" +
		"\x072\x02\x02\xD1\xD5\x070\x02\x02\xD2\xD4\x05\x04\x03\x02\xD3\xD2\x03" +
		"\x02\x02\x02\xD4\xD7\x03\x02\x02\x02\xD5\xD3\x03\x02\x02\x02\xD5\xD6\x03" +
		"\x02\x02\x02\xD6\xD8\x03\x02\x02\x02\xD7\xD5\x03\x02\x02\x02\xD8\xD9\x07" +
		"\r\x02\x02\xD9\x1F\x03\x02\x02\x02\xDA\xDB\x07\x12\x02\x02\xDB\xDC\x05" +
		"\"\x12\x02\xDC!\x03\x02\x02\x02\xDD\xDE\b\x12\x01\x02\xDE\xF5\x07\x03" +
		"\x02\x02\xDF\xF5\x07\x04\x02\x02\xE0\xF5\x07\x05\x02\x02\xE1\xF5\x077" +
		"\x02\x02\xE2\xE3\x05(\x15\x02\xE3\xE4\x07\x1C\x02\x02\xE4\xE5\x05\"\x12" +
		"\x0E\xE5\xF5\x03\x02\x02\x02\xE6\xE7\x075\x02\x02\xE7\xE8\x05&\x14\x02" +
		"\xE8\xE9\x076\x02\x02\xE9\xF5\x03\x02\x02\x02\xEA\xEB\t\x02\x02\x02\xEB" +
		"\xF5\x05\"\x12\v\xEC\xED\x071\x02\x02\xED\xEE\x05\"\x12\x02\xEE\xEF\x07" +
		"2\x02\x02\xEF\xF5\x03\x02\x02\x02\xF0\xF5\x05$\x13\x02\xF1\xF2\x077\x02" +
		"\x02\xF2\xF3\x07\x1B\x02\x02\xF3\xF5\x05$\x13\x02\xF4\xDD\x03\x02\x02" +
		"\x02\xF4\xDF\x03\x02\x02\x02\xF4\xE0\x03\x02\x02\x02\xF4\xE1\x03\x02\x02" +
		"\x02\xF4\xE2\x03\x02\x02\x02\xF4\xE6\x03\x02\x02\x02\xF4\xEA\x03\x02\x02" +
		"\x02\xF4\xEC\x03\x02\x02\x02\xF4\xF0\x03\x02\x02\x02\xF4\xF1\x03\x02\x02" +
		"\x02\xF5\u0112\x03\x02\x02\x02\xF6\xF7\f\f\x02\x02\xF7\xF8\x07\x18\x02" +
		"\x02\xF8\u0111\x05\"\x12\r\xF9\xFA\f\n\x02\x02\xFA\xFB\t\x03\x02\x02\xFB" +
		"\u0111\x05\"\x12\v\xFC\xFD\f\t\x02\x02\xFD\xFE\t\x04\x02\x02\xFE\u0111" +
		"\x05\"\x12\n\xFF\u0100\f\b\x02\x02\u0100\u0101\x07\x19\x02\x02\u0101\u0111" +
		"\x05\"\x12\t\u0102\u0103\f\x07\x02\x02\u0103\u0104\t\x05\x02\x02\u0104" +
		"\u0111\x05\"\x12\b\u0105\u0106\f\x06\x02\x02\u0106\u0107\t\x06\x02\x02" +
		"\u0107\u0111\x05\"\x12\x07\u0108\u0109\f\x10\x02\x02\u0109\u010A\x073" +
		"\x02\x02\u010A\u010B\x05\"\x12\x02\u010B\u010C\x074\x02\x02\u010C\u0111" +
		"\x03\x02\x02\x02\u010D\u010E\f\x0F\x02\x02\u010E\u010F\x07\x1B\x02\x02" +
		"\u010F\u0111\x077\x02\x02\u0110\xF6\x03\x02\x02\x02\u0110\xF9\x03\x02" +
		"\x02\x02\u0110\xFC\x03\x02\x02\x02\u0110\xFF\x03\x02\x02\x02\u0110\u0102" +
		"\x03\x02\x02\x02\u0110\u0105\x03\x02\x02\x02\u0110\u0108\x03\x02\x02\x02" +
		"\u0110\u010D\x03\x02\x02\x02\u0111\u0114\x03\x02\x02\x02\u0112\u0110\x03" +
		"\x02\x02\x02\u0112\u0113\x03\x02\x02\x02\u0113#\x03\x02\x02\x02\u0114" +
		"\u0112\x03\x02\x02\x02\u0115\u0116\x077\x02\x02\u0116\u0118\x071\x02\x02" +
		"\u0117\u0119\x05&\x14\x02\u0118\u0117\x03\x02\x02\x02\u0118\u0119\x03" +
		"\x02\x02\x02\u0119\u011A\x03\x02\x02\x02\u011A\u011B\x072\x02\x02\u011B" +
		"%\x03\x02\x02\x02\u011C\u0121\x05\"\x12\x02\u011D\u011E\x07\x1A\x02\x02" +
		"\u011E\u0120\x05\"\x12\x02\u011F\u011D\x03\x02\x02\x02\u0120\u0123\x03" +
		"\x02\x02\x02\u0121\u011F\x03\x02\x02\x02\u0121\u0122\x03\x02\x02\x02\u0122" +
		"\'\x03\x02\x02\x02\u0123\u0121\x03\x02\x02\x02\u0124\u0125\t\x07\x02\x02" +
		"\u0125)\x03\x02\x02\x02\x17-@J^c\x81\x87\x8E\x9A\xA3\xAE\xB9\xBE\xC6\xC9" +
		"\xD5\xF4\u0110\u0112\u0118\u0121";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!ArkcubeScriptParser.__ATN) {
			ArkcubeScriptParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(ArkcubeScriptParser._serializedATN));
		}

		return ArkcubeScriptParser.__ATN;
	}

}

export class ProgramContext extends ParserRuleContext {
	public EOF(): TerminalNode { return this.getToken(ArkcubeScriptParser.EOF, 0); }
	public stat(): StatContext[];
	public stat(i: number): StatContext;
	public stat(i?: number): StatContext | StatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StatContext);
		} else {
			return this.getRuleContext(i, StatContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_program; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterProgram) {
			listener.enterProgram(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitProgram) {
			listener.exitProgram(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitProgram) {
			return visitor.visitProgram(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StatContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_stat; }
	public copyFrom(ctx: StatContext): void {
		super.copyFrom(ctx);
	}
}
export class ImportStatementContext extends StatContext {
	public importStat(): ImportStatContext {
		return this.getRuleContext(0, ImportStatContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterImportStatement) {
			listener.enterImportStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitImportStatement) {
			listener.exitImportStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitImportStatement) {
			return visitor.visitImportStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ViewStatementContext extends StatContext {
	public viewStat(): ViewStatContext {
		return this.getRuleContext(0, ViewStatContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterViewStatement) {
			listener.enterViewStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitViewStatement) {
			listener.exitViewStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitViewStatement) {
			return visitor.visitViewStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class VariableDeclStatementContext extends StatContext {
	public variableDecl(): VariableDeclContext {
		return this.getRuleContext(0, VariableDeclContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterVariableDeclStatement) {
			listener.enterVariableDeclStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitVariableDeclStatement) {
			listener.exitVariableDeclStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitVariableDeclStatement) {
			return visitor.visitVariableDeclStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class FunctionDeclStatementContext extends StatContext {
	public functionDecl(): FunctionDeclContext {
		return this.getRuleContext(0, FunctionDeclContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterFunctionDeclStatement) {
			listener.enterFunctionDeclStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitFunctionDeclStatement) {
			listener.exitFunctionDeclStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitFunctionDeclStatement) {
			return visitor.visitFunctionDeclStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ControlStatementContext extends StatContext {
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public ifStat(): IfStatContext | undefined {
		return this.tryGetRuleContext(0, IfStatContext);
	}
	public whileStat(): WhileStatContext | undefined {
		return this.tryGetRuleContext(0, WhileStatContext);
	}
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterControlStatement) {
			listener.enterControlStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitControlStatement) {
			listener.exitControlStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitControlStatement) {
			return visitor.visitControlStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ReturnStatementContext extends StatContext {
	public returnStat(): ReturnStatContext {
		return this.getRuleContext(0, ReturnStatContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterReturnStatement) {
			listener.enterReturnStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitReturnStatement) {
			listener.exitReturnStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitReturnStatement) {
			return visitor.visitReturnStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ExprStatementContext extends StatContext {
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	constructor(ctx: StatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterExprStatement) {
			listener.enterExprStatement(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitExprStatement) {
			listener.exitExprStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitExprStatement) {
			return visitor.visitExprStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ImportStatContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_importStat; }
	public copyFrom(ctx: ImportStatContext): void {
		super.copyFrom(ctx);
	}
}
export class ModuleAliasContext extends ImportStatContext {
	public _name!: Token;
	public _alias!: Token;
	public Import(): TerminalNode { return this.getToken(ArkcubeScriptParser.Import, 0); }
	public As(): TerminalNode { return this.getToken(ArkcubeScriptParser.As, 0); }
	public StringLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.StringLiteral, 0); }
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(ctx: ImportStatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterModuleAlias) {
			listener.enterModuleAlias(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitModuleAlias) {
			listener.exitModuleAlias(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitModuleAlias) {
			return visitor.visitModuleAlias(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ModuleSymbolContext extends ImportStatContext {
	public _name!: Token;
	public _mod!: Token;
	public From(): TerminalNode { return this.getToken(ArkcubeScriptParser.From, 0); }
	public Import(): TerminalNode { return this.getToken(ArkcubeScriptParser.Import, 0); }
	public StringLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.StringLiteral, 0); }
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(ctx: ImportStatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterModuleSymbol) {
			listener.enterModuleSymbol(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitModuleSymbol) {
			listener.exitModuleSymbol(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitModuleSymbol) {
			return visitor.visitModuleSymbol(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ModuleSymbolAliasContext extends ImportStatContext {
	public _name!: Token;
	public _mod!: Token;
	public _alias!: Token;
	public From(): TerminalNode { return this.getToken(ArkcubeScriptParser.From, 0); }
	public Import(): TerminalNode { return this.getToken(ArkcubeScriptParser.Import, 0); }
	public As(): TerminalNode { return this.getToken(ArkcubeScriptParser.As, 0); }
	public StringLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.StringLiteral, 0); }
	public Identifier(): TerminalNode[];
	public Identifier(i: number): TerminalNode;
	public Identifier(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.Identifier);
		} else {
			return this.getToken(ArkcubeScriptParser.Identifier, i);
		}
	}
	constructor(ctx: ImportStatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterModuleSymbolAlias) {
			listener.enterModuleSymbolAlias(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitModuleSymbolAlias) {
			listener.exitModuleSymbolAlias(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitModuleSymbolAlias) {
			return visitor.visitModuleSymbolAlias(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ModuleAllSymbolContext extends ImportStatContext {
	public _name!: Token;
	public From(): TerminalNode { return this.getToken(ArkcubeScriptParser.From, 0); }
	public Import(): TerminalNode { return this.getToken(ArkcubeScriptParser.Import, 0); }
	public Star(): TerminalNode { return this.getToken(ArkcubeScriptParser.Star, 0); }
	public StringLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.StringLiteral, 0); }
	constructor(ctx: ImportStatContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterModuleAllSymbol) {
			listener.enterModuleAllSymbol(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitModuleAllSymbol) {
			listener.exitModuleAllSymbol(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitModuleAllSymbol) {
			return visitor.visitModuleAllSymbol(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ViewStatContext extends ParserRuleContext {
	public cellViewStat(): CellViewStatContext | undefined {
		return this.tryGetRuleContext(0, CellViewStatContext);
	}
	public cellEXViewStat(): CellEXViewStatContext | undefined {
		return this.tryGetRuleContext(0, CellEXViewStatContext);
	}
	public cellDBViewStat(): CellDBViewStatContext | undefined {
		return this.tryGetRuleContext(0, CellDBViewStatContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_viewStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterViewStat) {
			listener.enterViewStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitViewStat) {
			listener.exitViewStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitViewStat) {
			return visitor.visitViewStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CellViewStatContext extends ParserRuleContext {
	public CellView(): TerminalNode { return this.getToken(ArkcubeScriptParser.CellView, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public arguments(): ArgumentsContext {
		return this.getRuleContext(0, ArgumentsContext);
	}
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_cellViewStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterCellViewStat) {
			listener.enterCellViewStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitCellViewStat) {
			listener.exitCellViewStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitCellViewStat) {
			return visitor.visitCellViewStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CellEXViewStatContext extends ParserRuleContext {
	public CellEXView(): TerminalNode { return this.getToken(ArkcubeScriptParser.CellEXView, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public arguments(): ArgumentsContext {
		return this.getRuleContext(0, ArgumentsContext);
	}
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_cellEXViewStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterCellEXViewStat) {
			listener.enterCellEXViewStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitCellEXViewStat) {
			listener.exitCellEXViewStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitCellEXViewStat) {
			return visitor.visitCellEXViewStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CellDBViewStatContext extends ParserRuleContext {
	public CellDBView(): TerminalNode { return this.getToken(ArkcubeScriptParser.CellDBView, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public arguments(): ArgumentsContext {
		return this.getRuleContext(0, ArgumentsContext);
	}
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_cellDBViewStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterCellDBViewStat) {
			listener.enterCellDBViewStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitCellDBViewStat) {
			listener.exitCellDBViewStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitCellDBViewStat) {
			return visitor.visitCellDBViewStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class VariableDeclContext extends ParserRuleContext {
	public type(): TypeContext {
		return this.getRuleContext(0, TypeContext);
	}
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	public Equal(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Equal, 0); }
	public expr(): ExprContext | undefined {
		return this.tryGetRuleContext(0, ExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_variableDecl; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterVariableDecl) {
			listener.enterVariableDecl(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitVariableDecl) {
			listener.exitVariableDecl(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitVariableDecl) {
			return visitor.visitVariableDecl(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TypeContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_type; }
	public copyFrom(ctx: TypeContext): void {
		super.copyFrom(ctx);
	}
}
export class ArrayTypeContext extends TypeContext {
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	public LeftBracket(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftBracket, 0); }
	public RightBracket(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightBracket, 0); }
	constructor(ctx: TypeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterArrayType) {
			listener.enterArrayType(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitArrayType) {
			listener.exitArrayType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitArrayType) {
			return visitor.visitArrayType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class SimpleTypeContext extends TypeContext {
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(ctx: TypeContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterSimpleType) {
			listener.enterSimpleType(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitSimpleType) {
			listener.exitSimpleType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitSimpleType) {
			return visitor.visitSimpleType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionDeclContext extends ParserRuleContext {
	public type(): TypeContext {
		return this.getRuleContext(0, TypeContext);
	}
	public Function(): TerminalNode { return this.getToken(ArkcubeScriptParser.Function, 0); }
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	public parameterList(): ParameterListContext | undefined {
		return this.tryGetRuleContext(0, ParameterListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_functionDecl; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterFunctionDecl) {
			listener.enterFunctionDecl(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitFunctionDecl) {
			listener.exitFunctionDecl(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitFunctionDecl) {
			return visitor.visitFunctionDecl(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ParameterListContext extends ParserRuleContext {
	public parameter(): ParameterContext[];
	public parameter(i: number): ParameterContext;
	public parameter(i?: number): ParameterContext | ParameterContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ParameterContext);
		} else {
			return this.getRuleContext(i, ParameterContext);
		}
	}
	public Comma(): TerminalNode[];
	public Comma(i: number): TerminalNode;
	public Comma(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.Comma);
		} else {
			return this.getToken(ArkcubeScriptParser.Comma, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_parameterList; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterParameterList) {
			listener.enterParameterList(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitParameterList) {
			listener.exitParameterList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitParameterList) {
			return visitor.visitParameterList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ParameterContext extends ParserRuleContext {
	public type(): TypeContext {
		return this.getRuleContext(0, TypeContext);
	}
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_parameter; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterParameter) {
			listener.enterParameter(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitParameter) {
			listener.exitParameter(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitParameter) {
			return visitor.visitParameter(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BlockContext extends ParserRuleContext {
	public stat(): StatContext[];
	public stat(i: number): StatContext;
	public stat(i?: number): StatContext | StatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StatContext);
		} else {
			return this.getRuleContext(i, StatContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_block; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterBlock) {
			listener.enterBlock(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitBlock) {
			listener.exitBlock(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitBlock) {
			return visitor.visitBlock(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IfStatContext extends ParserRuleContext {
	public If(): TerminalNode { return this.getToken(ArkcubeScriptParser.If, 0); }
	public LeftParen(): TerminalNode[];
	public LeftParen(i: number): TerminalNode;
	public LeftParen(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.LeftParen);
		} else {
			return this.getToken(ArkcubeScriptParser.LeftParen, i);
		}
	}
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public RightParen(): TerminalNode[];
	public RightParen(i: number): TerminalNode;
	public RightParen(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.RightParen);
		} else {
			return this.getToken(ArkcubeScriptParser.RightParen, i);
		}
	}
	public Semi(): TerminalNode[];
	public Semi(i: number): TerminalNode;
	public Semi(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.Semi);
		} else {
			return this.getToken(ArkcubeScriptParser.Semi, i);
		}
	}
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	public stat(): StatContext[];
	public stat(i: number): StatContext;
	public stat(i?: number): StatContext | StatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StatContext);
		} else {
			return this.getRuleContext(i, StatContext);
		}
	}
	public Elseif(): TerminalNode[];
	public Elseif(i: number): TerminalNode;
	public Elseif(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.Elseif);
		} else {
			return this.getToken(ArkcubeScriptParser.Elseif, i);
		}
	}
	public Else(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Else, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_ifStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterIfStat) {
			listener.enterIfStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitIfStat) {
			listener.exitIfStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitIfStat) {
			return visitor.visitIfStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WhileStatContext extends ParserRuleContext {
	public While(): TerminalNode { return this.getToken(ArkcubeScriptParser.While, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public Semi(): TerminalNode { return this.getToken(ArkcubeScriptParser.Semi, 0); }
	public End(): TerminalNode { return this.getToken(ArkcubeScriptParser.End, 0); }
	public stat(): StatContext[];
	public stat(i: number): StatContext;
	public stat(i?: number): StatContext | StatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StatContext);
		} else {
			return this.getRuleContext(i, StatContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_whileStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterWhileStat) {
			listener.enterWhileStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitWhileStat) {
			listener.exitWhileStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitWhileStat) {
			return visitor.visitWhileStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ReturnStatContext extends ParserRuleContext {
	public Return(): TerminalNode { return this.getToken(ArkcubeScriptParser.Return, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_returnStat; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterReturnStat) {
			listener.enterReturnStat(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitReturnStat) {
			listener.exitReturnStat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitReturnStat) {
			return visitor.visitReturnStat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExprContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_expr; }
	public copyFrom(ctx: ExprContext): void {
		super.copyFrom(ctx);
	}
}
export class NumberContext extends ExprContext {
	public Number(): TerminalNode { return this.getToken(ArkcubeScriptParser.Number, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterNumber) {
			listener.enterNumber(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitNumber) {
			listener.exitNumber(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitNumber) {
			return visitor.visitNumber(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class StringLiteralContext extends ExprContext {
	public StringLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.StringLiteral, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterStringLiteral) {
			listener.enterStringLiteral(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitStringLiteral) {
			listener.exitStringLiteral(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitStringLiteral) {
			return visitor.visitStringLiteral(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class BooleanLiteralContext extends ExprContext {
	public BooleanLiteral(): TerminalNode { return this.getToken(ArkcubeScriptParser.BooleanLiteral, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterBooleanLiteral) {
			listener.enterBooleanLiteral(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitBooleanLiteral) {
			listener.exitBooleanLiteral(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitBooleanLiteral) {
			return visitor.visitBooleanLiteral(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class NameContext extends ExprContext {
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterName) {
			listener.enterName(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitName) {
			listener.exitName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitName) {
			return visitor.visitName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ArrayIndexContext extends ExprContext {
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public LeftBracket(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftBracket, 0); }
	public RightBracket(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightBracket, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterArrayIndex) {
			listener.enterArrayIndex(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitArrayIndex) {
			listener.exitArrayIndex(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitArrayIndex) {
			return visitor.visitArrayIndex(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class MemberRangeContext extends ExprContext {
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	public Dot(): TerminalNode { return this.getToken(ArkcubeScriptParser.Dot, 0); }
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterMemberRange) {
			listener.enterMemberRange(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitMemberRange) {
			listener.exitMemberRange(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitMemberRange) {
			return visitor.visitMemberRange(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class DimColonContext extends ExprContext {
	public dim(): DimContext {
		return this.getRuleContext(0, DimContext);
	}
	public Colon(): TerminalNode { return this.getToken(ArkcubeScriptParser.Colon, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterDimColon) {
			listener.enterDimColon(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitDimColon) {
			listener.exitDimColon(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitDimColon) {
			return visitor.visitDimColon(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class MemberSetContext extends ExprContext {
	public LeftBrace(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftBrace, 0); }
	public arguments(): ArgumentsContext {
		return this.getRuleContext(0, ArgumentsContext);
	}
	public RightBrace(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightBrace, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterMemberSet) {
			listener.enterMemberSet(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitMemberSet) {
			listener.exitMemberSet(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitMemberSet) {
			return visitor.visitMemberSet(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class PowerLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Caret(): TerminalNode { return this.getToken(ArkcubeScriptParser.Caret, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterPowerLike) {
			listener.enterPowerLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitPowerLike) {
			listener.exitPowerLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitPowerLike) {
			return visitor.visitPowerLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class PrefixExpressionContext extends ExprContext {
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	public Plus(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Plus, 0); }
	public Minus(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Minus, 0); }
	public Tilde(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Tilde, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterPrefixExpression) {
			listener.enterPrefixExpression(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitPrefixExpression) {
			listener.exitPrefixExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitPrefixExpression) {
			return visitor.visitPrefixExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class MultiplyLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Star(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Star, 0); }
	public Div(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Div, 0); }
	public Div2(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Div2, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterMultiplyLike) {
			listener.enterMultiplyLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitMultiplyLike) {
			listener.exitMultiplyLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitMultiplyLike) {
			return visitor.visitMultiplyLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class PlusLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Plus(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Plus, 0); }
	public Minus(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Minus, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterPlusLike) {
			listener.enterPlusLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitPlusLike) {
			listener.exitPlusLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitPlusLike) {
			return visitor.visitPlusLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class ListLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Or(): TerminalNode { return this.getToken(ArkcubeScriptParser.Or, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterListLike) {
			listener.enterListLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitListLike) {
			listener.exitListLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitListLike) {
			return visitor.visitListLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class CompareLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Equal(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Equal, 0); }
	public NotEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.NotEqual, 0); }
	public Greater(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Greater, 0); }
	public GreaterEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.GreaterEqual, 0); }
	public Less(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Less, 0); }
	public LessEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.LessEqual, 0); }
	public StrEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrEqual, 0); }
	public StrNotEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrNotEqual, 0); }
	public StrGreater(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrGreater, 0); }
	public StrGreaterEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrGreaterEqual, 0); }
	public StrLess(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrLess, 0); }
	public StrLessEqual(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StrLessEqual, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterCompareLike) {
			listener.enterCompareLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitCompareLike) {
			listener.exitCompareLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitCompareLike) {
			return visitor.visitCompareLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class LogicLikeContext extends ExprContext {
	public _left!: ExprContext;
	public _op!: Token;
	public _right!: ExprContext;
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Percent(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Percent, 0); }
	public And(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.And, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterLogicLike) {
			listener.enterLogicLike(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitLogicLike) {
			listener.exitLogicLike(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitLogicLike) {
			return visitor.visitLogicLike(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class PriorityExpressionContext extends ExprContext {
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public expr(): ExprContext {
		return this.getRuleContext(0, ExprContext);
	}
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterPriorityExpression) {
			listener.enterPriorityExpression(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitPriorityExpression) {
			listener.exitPriorityExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitPriorityExpression) {
			return visitor.visitPriorityExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class FunctionApplyContext extends ExprContext {
	public functionCall(): FunctionCallContext {
		return this.getRuleContext(0, FunctionCallContext);
	}
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterFunctionApply) {
			listener.enterFunctionApply(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitFunctionApply) {
			listener.exitFunctionApply(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitFunctionApply) {
			return visitor.visitFunctionApply(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}
export class DotFunctionApplyContext extends ExprContext {
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	public Dot(): TerminalNode { return this.getToken(ArkcubeScriptParser.Dot, 0); }
	public functionCall(): FunctionCallContext {
		return this.getRuleContext(0, FunctionCallContext);
	}
	constructor(ctx: ExprContext) {
		super(ctx.parent, ctx.invokingState);
		this.copyFrom(ctx);
	}
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterDotFunctionApply) {
			listener.enterDotFunctionApply(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitDotFunctionApply) {
			listener.exitDotFunctionApply(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitDotFunctionApply) {
			return visitor.visitDotFunctionApply(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionCallContext extends ParserRuleContext {
	public Identifier(): TerminalNode { return this.getToken(ArkcubeScriptParser.Identifier, 0); }
	public LeftParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.LeftParen, 0); }
	public RightParen(): TerminalNode { return this.getToken(ArkcubeScriptParser.RightParen, 0); }
	public arguments(): ArgumentsContext | undefined {
		return this.tryGetRuleContext(0, ArgumentsContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_functionCall; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterFunctionCall) {
			listener.enterFunctionCall(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitFunctionCall) {
			listener.exitFunctionCall(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitFunctionCall) {
			return visitor.visitFunctionCall(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArgumentsContext extends ParserRuleContext {
	public expr(): ExprContext[];
	public expr(i: number): ExprContext;
	public expr(i?: number): ExprContext | ExprContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExprContext);
		} else {
			return this.getRuleContext(i, ExprContext);
		}
	}
	public Comma(): TerminalNode[];
	public Comma(i: number): TerminalNode;
	public Comma(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(ArkcubeScriptParser.Comma);
		} else {
			return this.getToken(ArkcubeScriptParser.Comma, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_arguments; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterArguments) {
			listener.enterArguments(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitArguments) {
			listener.exitArguments(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitArguments) {
			return visitor.visitArguments(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DimContext extends ParserRuleContext {
	public Identifier(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.Identifier, 0); }
	public StringLiteral(): TerminalNode | undefined { return this.tryGetToken(ArkcubeScriptParser.StringLiteral, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return ArkcubeScriptParser.RULE_dim; }
	// @Override
	public enterRule(listener: ArkcubeScriptListener): void {
		if (listener.enterDim) {
			listener.enterDim(this);
		}
	}
	// @Override
	public exitRule(listener: ArkcubeScriptListener): void {
		if (listener.exitDim) {
			listener.exitDim(this);
		}
	}
	// @Override
	public accept<Result>(visitor: ArkcubeScriptVisitor<Result>): Result {
		if (visitor.visitDim) {
			return visitor.visitDim(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


